GUI_State.c

Go to the documentation of this file.

#include "derivative.h"
#include "Compile_Options.h"
#include "GUI_State.h"
#include "SM.h"
#include "SBC_AL.h"
#include "CG147.h"
#include "CG147_Diag.h"
#include "Central_Accel_AL.h"
#include "MMA68xx.h"
#include "MMA68xx_Diag.h"
#include "DSPI.h"
#include "HAL.h"
#include "MailScheduler.h"
#include "Application_Globals.h"
#include "MMA51xx.h"
#include "SIU.h"
#include "Labview.h"
#include "IntcInterrupts.h"
#include "Utils.h"
#include "LIN_UART.h"
#include <Limits.h>
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
static const uint16_t cau16PreGUIValidStates[] =
{
  SM_STATE_ERROR, SM_STATE_DEPLOYMENT };

static const uint8_t cau8SampleTable[] = 
{
  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 16, 18, 19, 20,
  21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40
};
static const uint8_t cau8GUIStat00[] = "Please wait while the command is being executed.";
static const uint8_t cau8GUIStat01[] = "The command was not recognized.";
static const uint8_t cau8GUIStat02[] = "The command has been executed.";
static const uint8_t cau8GUIStat03[] = "Active squibs: ";
static const uint8_t cau8GUIStat04[] = "Active satellites: ";
static const GUICmdString_t catGUIValidCommands[] = 
{
  "3**", "a**", "c**", "e0*", "e1*", "g0*", "g1*", "i0*", "i1*", "k**", "m**", 
  "o**", "q**", "s**", "C**"
};
/*
 ******************************************************************************
 * State Globals
 ******************************************************************************
 */
static uint8_t gu8GUIStateStepCounter;
/*
 ******************************************************************************
 * u32fnStateGUI
 ******************************************************************************
 */
uint32_t u32fnStateGUI(void)
{
#ifdef USE_LABVIEW  
  uint16_t au16LabviewData[8u];
  uint8_t au16LabviewRawResponse[15];
  uint8_t au8TextResponse[256];
  uint8_t u8TextSize;
#endif
  uint32_t u32Status;
  uint32_t u32GUITime;
  uint8_t  u8ResponseSize;
  

  
  /* Verify that we can execute - Previous state ended correctly */
  u32Status = u32fnSMValidateCurrentState((uint16_t*)cau16PreGUIValidStates,
                                          N_ELEMENTS(cau16PreGUIValidStates));
  if(CLEAR == u32Status)
  {
    /* Here comes the real contents of the state */
    LOCK_STATE_EXECUTION();

#ifdef USE_LABVIEW  
    if(gu8GUIStateFirstRun == GUI_STATE_RUN_HAS_BEEN_EXECUTED)
    {
      /* Enable communication with the PC */
      vfnLVEnable(TRUE);
    }
    else
    {
      /* Remember we've been through this */
      gu8GUIStateFirstRun = GUI_STATE_RUN_HAS_BEEN_EXECUTED;
      gu8GUIStateStepCounter = CLEAR;
      gau8LabViewRxCmd[CLEAR] = CLEAR;
      
      /* Configure our device to receive data */
      if(CLEAR == u8fnLVConfigRxCmd())
      {
        /* Go on */
      }
      else
      {
        /* We should flag it as an error, but we don't really care because */
        /* this is just a demo. Instead, we will reset gu8GUIStateFirstRun */
        /* in order to do this again */
        gu8GUIStateFirstRun = CLEAR;
      }
    }
    
    /* ********* True behavior of the state starts here **********************/
    /* Assign the time */
    SCHED_WHAT_IS_THE_TIME(u32GUITime);
    
    /* Now we wait. We shall not pass more time here than we should */
    do
    {
      if(CLEAR == u8fnLVReceiveCmd())
      {
        /* We have a request for an action. Treat it. Execution of the         */
        /* regular state-machine, including timing, etc, goes to the way-side  */
        /* But first, inform the user we have gotten the command. */
        vfnCopyArray((uint8_t*)&cau8GUIStat00, (uint8_t*)au8TextResponse, \
                     N_ELEMENTS(cau8GUIStat00));
        /* Allow any pending message to finish */
        (void)u8fnLVWaitForTxPort();
        u32Status = u8fnLabViewSendMSorMP((uint8_t*)au8TextResponse, 
                                          N_ELEMENTS(cau8GUIStat00),
                                          LV_SEND_SERIALLY, LV_TS_MSG);
        
        u32Status = u32fnGUISwitchCase((uint8_t*)&gau8LabViewRxCmd[LV_CMD],
                                       (uint8_t*)au16LabviewRawResponse,
                                       (uint8_t*)&u8ResponseSize,
                                       (uint8_t*)&au8TextResponse,
                                       (uint8_t*)&u8TextSize);
        u32Status = u32fnGUISendResponseFrame((const uint8_t*)&gau8LabViewRxCmd[LV_CMD],
                                              (const uint8_t*)au16LabviewRawResponse,
                                              (const uint8_t*)&u8ResponseSize,
                                              (const uint8_t*)au8TextResponse,
                                              u8TextSize);
        
        gau8LabViewRxCmd[CLEAR] = CLEAR;
        
#ifndef USE_AUTO_SYNC
        /* Ensure that we have data in our satellites when we exit this fn */
        (void)u8fnSBCSchedulePSync();
        DELAY_MSEC(1u);
#endif
        
      }
      else
      {
        /* Let's tell our GUI what the status is of our satellites + squibs */
        vfnGUISatAndSquibState(LV_SEND_IN_PARALLEL, gu8GUIStateStepCounter++);
        if((CLEAR == gau8LINUARTWordsTx[LABVIEW_SCI]) & (gu8GUIStateStepCounter > 14))
        {
          vfnGUIStateFormatCurveData((uint16_t*)&au16LabviewData);
          vfnDisplaySCIDataParallel(LV_DA_MSG, LV_16, 6u, 1u,
                                    (uint8_t*)au16LabviewData);
          if(0x100u > gu8GUIStateStepCounter)
          {
            /* Keep counting */
          }
          else
          {
            gu8GUIStateStepCounter = CLEAR;
          }
          
        }
        else
        {
          /* Nothing */
         
        }
      }
    }while(SCHED_100US_PERIOD  > u32fnSchedHasTimeElapsed(u32GUITime));
    
    /* Disable communication with the PC */
    vfnLVEnable(CLEAR);
#endif /* Use Labview */    
    /* Unlock the state */
    UNLOCK_STATE_EXECUTION();
  }
  else
  {
    /* Leave */
  }

  /* Set the next state */
  if(CLEAR == u32Status)
  {
    vfnSMWriteNextState(SM_APPLICATION_START);
  }
  else
  {
    vfnSMWriteNextState(SM_STATE_ERROR);
  }
  return (u32Status);
}
/*
 ******************************************************************************
 * vfnGUIStateFormatCurveData
 ******************************************************************************
 */
void vfnGUIStateFormatCurveData(uint16_t* au16LabviewData)
{
  /* Data manipulation occurs here */
  if(BIT0 & gu16ActivePSI5Channels)
  {
    au16LabviewData[0u] = gau16RawAccels[0u];
  }
  else
  {
    au16LabviewData[0u] = 512;
  }
  if(BIT3 & gu16ActivePSI5Channels)
  {
    au16LabviewData[1u] = gau16RawAccels[3u];
  }
  else
  {
    au16LabviewData[1u] = 512;
  }
  if(BIT6 & gu16ActivePSI5Channels)
  {
    au16LabviewData[2u] = gau16RawAccels[6u];
  }
  else
  {
    au16LabviewData[2u] = 512;
  }
  if(BIT9 & gu16ActivePSI5Channels)
  {
    au16LabviewData[3u] = gau16RawAccels[9u];
  }
  else
  {
    au16LabviewData[3u] = 512;
  }
  au16LabviewData[4u] = gau16RawAccels[12u];
  au16LabviewData[5u] = gau16RawAccels[13u];
  return;
}  
/*
 ******************************************************************************
 * u32fnGUISwitchCase
 ******************************************************************************
 */
uint32_t u32fnGUISwitchCase(const uint8_t* pu8Cmd, 
                            uint8_t* pu8RawResponse, 
                            uint8_t* pu8Size,
                            uint8_t* pu8TextResponse,
                            uint8_t* pu8TextSize)
{
  uint32_t u32Status;
  uint8_t  au8ScratchPad[4u];
  uint32_t u32ScratchPad;
  uint8_t  au8Args[N_GUI_ARGS];
  uint8_t  u8Counter;
  u32Status = CLEAR;
  
  /* Decode the ASCII elements of the arguments and place them as Hex */
  vfnASCIIByteToHex((uint8_t*)(pu8Cmd + (uint8_t)1u), (uint8_t*)&au8Args, N_GUI_ARGS);
  
  /* Raw response shall contain the Pass/Fail (TRUE/CLEAR) result as the */
  /* first element of the RawResponse; following elements are treated on */
  /* a case-by-case scenario. */
  
  /* We will assume that the command received is good, unless shown otherwise */
  vfnCopyArray((uint8_t*)&cau8GUIStat02, pu8TextResponse, \
                                  N_ELEMENTS(cau8GUIStat02));
  *pu8TextSize = N_ELEMENTS(cau8GUIStat02);
  
  DELAY_MSEC(1u);
  
  switch(*pu8Cmd)
  {
    case ('1'):
    {
      /* In this case, we must figure out what elements in a list need to be */
      /* active.                                                             */
      vfnVerifyValidityOfCmd(pu8Cmd, 
                             (const GUICmdString_t*)&catGUIValidCommands,
                              N_ELEMENTS(catGUIValidCommands),
                              pu8Size);
      *pu8RawResponse = *pu8Size;
      break;
    }
    case ('3'):
    {
      /* Read sample registers */
      vfnDisplaySCIRegistersInTable(LV_RS_MSG, 
                                    CLEAR, 
                                    40, 
                                    (uint8_t*)&cau8SampleTable);
      break;
    }
    case ('a'):
    {
      /* Cap test */
      
      vfnGUISBCCapTests(pu8Size, pu8RawResponse,
                        au8Args[CLEAR], CLEAR);
      break;
    }
    case ('c'):
    {
      /* ESR test */
      vfnGUISBCCapTests(pu8Size, pu8RawResponse,
                        au8Args[CLEAR], (uint8_t)1u);
      
      break;
    }
    case ('e'):
    {
      /* Polarity protection check */
      vfnGUISBCCapTests(pu8Size, pu8RawResponse,
                        au8Args[CLEAR], (uint8_t)2u);
      break;
    }
    case ('g'):
    {
      /* Low leakage test */
      vfnGUISBCLeakageTests(au8Args[CLEAR],
                            au8Args[TRUE], 
                            TRUE, 
                            pu8RawResponse);
      *pu8Size = 7u;
      break;
    }
    case ('i'):
    {
      /* High leakage test */
      vfnGUISBCLeakageTests(au8Args[CLEAR],
                            au8Args[TRUE], 
                            CLEAR, 
                            pu8RawResponse);
      *pu8Size = 7u;
      break;
    }
    case ('k'):
    {
      /* Resistance test */
      u32ScratchPad = 
        u32fnSBCFLMResistanceMeasurement(cau8SBCInitialTestAoutRoutesIGH[au8Args[TRUE]],
                                         cau8SBCInitialTestAoutRoutesIGL[au8Args[TRUE]],
                                         au8Args[TRUE]);
     *pu8RawResponse =  (uint8_t)(CLEAR == u32ScratchPad);
     *(pu8RawResponse + 1u) = (uint8_t)(u32ScratchPad >> BITS_IN_24);
     *(pu8RawResponse + 2u) = (uint8_t)(u32ScratchPad >> BITS_IN_16);
     *(pu8RawResponse + 3u) = (uint8_t)(u32ScratchPad >> BITS_IN_BYTE);
     *(pu8RawResponse + 4u) = (uint8_t)u32ScratchPad;
     *pu8Size = 5u;
      break;
    }
    case ('m'):
    {
      /* Mux test */
      u32ScratchPad = CLEAR;
      for(u8Counter = CLEAR; u8Counter < 5u; u8Counter++)
      {
        u32ScratchPad |= u32fnSBCTestMuxAndADC(u8Counter);
        DELAY_MSEC(10u);
      }
      *pu8RawResponse =  (uint8_t)(CLEAR == u32ScratchPad);
      *(pu8RawResponse + 1u) = (uint8_t)(u32ScratchPad >> BITS_IN_24);
      *(pu8RawResponse + 2u) = (uint8_t)(u32ScratchPad >> BITS_IN_16);
      *(pu8RawResponse + 3u) = (uint8_t)(u32ScratchPad >> BITS_IN_BYTE);
      *(pu8RawResponse + 4u) = (uint8_t)u32ScratchPad;
      *pu8Size = 5u;
      break;
    }
    case ('o'):
    {
      /* CG147's ADC test */
      u32ScratchPad = CLEAR;
      for(u8Counter = 5u; u8Counter < cu8SizeOfTestAnaHeadSettings; u8Counter++)
      {
        u32ScratchPad |= u32fnSBCTestMuxAndADC(u8Counter);
        DELAY_MSEC(10u);
      }
      *pu8RawResponse =  (uint8_t)(CLEAR == u32ScratchPad);
      *(pu8RawResponse + 1u) = (uint8_t)(u32ScratchPad >> BITS_IN_24);
      *(pu8RawResponse + 2u) = (uint8_t)(u32ScratchPad >> BITS_IN_16);
      *(pu8RawResponse + 3u) = (uint8_t)(u32ScratchPad >> BITS_IN_BYTE);
      *(pu8RawResponse + 4u) = (uint8_t)u32ScratchPad;
      *pu8Size = 5u;
      break;
    }
    case('q'):
    {
      /* Select the channel we want to measure */
      au8ScratchPad[CLEAR] = (uint8_t)((au8Args[CLEAR] & 0x0F) << BITS_IN_NIBBLE);
      au8ScratchPad[CLEAR] |= (BIT7 | (uint8_t)au8Args[TRUE]); 
      u32ScratchPad = u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT,
                                                    SBC_AOUT_CTRL,
                                                    au8ScratchPad[CLEAR],
                                                    (uint16_t*)&au8ScratchPad, 
                                                    (uint32_t*)&au8ScratchPad);
      /* Wait for the level to take */
      DELAY_MSEC(1u);
      
      /* Read it back */
      /* Store the current Voltage level in Aout. This is our reference point. */
      vfnTransferADCResults(CLEAR, (uint16_t*)&au8ScratchPad, 2u);
      
      /* Wait just to be sure */
      DELAY_MSEC(2u);
      
      /* Start constructing result */
      *pu8RawResponse =  (uint8_t)(TRUE);
      *(pu8RawResponse + 1u) = au8ScratchPad[CLEAR];
      *(pu8RawResponse + 2u) = au8ScratchPad[1];
      *(pu8RawResponse + 3u) = au8ScratchPad[2];
      *(pu8RawResponse + 4u) = au8ScratchPad[3];
      
      *pu8Size = 3u;
      break;
    }
    case('s'):
    {
      /* Check satellites */
      au8ScratchPad[CLEAR] = CLEAR;
      vfnGUICheckSatellites((uint16_t*)&au8ScratchPad, pu8RawResponse);
      *pu8Size = (uint8_t)1u;
      break;
    }
    case ('A'):
    {
      /* Cap test */
      break;
    }
    case ('C'):
    {
      /* Central Accelerometer Self test */
      /* Reset to allow future re-programming */
      u32Status = (*u8pfnMMA6800BatchOp[MMA6800_TRANSFER_MODE_IS_SCHEDULED])
                (MAIN_ACCELERO_SPI_CONFIG,(uint16_t*)cau16MMA6800ResetSettings,
                (uint16_t*)gau8MMA6800GlobalResult,
                cu8SizeofMMA6800ResetSettings);        
      DELAY_MSEC(1u);
      /* Load init settings */      
      u32Status = (*u8pfnMMA6800BatchOp[MMA6800_TRANSFER_MODE_IS_SCHEDULED])
                (MAIN_ACCELERO_SPI_CONFIG,(uint16_t*)cau16MMA6800InitSettings,
                (uint16_t*)gau8MMA6800GlobalResult,
                cu8SizeofMMA6800InitSettings);       
      DELAY_MSEC(1u);
      if (CLEAR == au8Args[CLEAR])
      {
         /* CA Self test for both axis */      
         u32ScratchPad = u32fnCAInitSelfTest();
      }
      else
      {
        if (CLEAR == au8Args[1])
        {
          /* CA Self test for X axis */      
          u32ScratchPad = u32fnCASelfTest((uint8_t) MMA6800_READ_X);          
        }
        else
        {
          /* CA Self test for Y axis */      
          u32ScratchPad = u32fnCASelfTest((uint8_t) MMA6800_READ_Y);          
        }
      }
      /* ENDINIT bit set */
      DELAY_MSEC(1u);      
      u32Status = u8fnMMA6800WriteRegister(MAIN_ACCELERO_SPI_CONFIG,
                                           MMA6800_TRANSFER_MODE_IS_SCHEDULED,
                                           MMA6800_DEVCFG, 0x35, 
                                           (uint16_t*) &gau8MMA6800GlobalResult);
      
     *pu8RawResponse =  (uint8_t)(CLEAR == u32ScratchPad);
     *(pu8RawResponse + 1u) = (uint8_t)(u32ScratchPad >> BITS_IN_24);
     *(pu8RawResponse + 2u) = (uint8_t)(u32ScratchPad >> BITS_IN_16);
     *(pu8RawResponse + 3u) = (uint8_t)(u32ScratchPad >> BITS_IN_BYTE);
     *(pu8RawResponse + 4u) = (uint8_t)u32ScratchPad;
     *pu8Size = 5u;
      break;
    }
    case ('E'):
    {
      /* Cap test */
      break;
    }
    case ('G'):
    {
      /* Cap test */
      break;
    }
    case ('I'):
    {
      /* Cap test */
      break;
    }
      
    default:
    {
      /* Fail whatever test we were requested */
      *pu8RawResponse = CLEAR;
      *pu8Size = (uint8_t)1u;
      vfnCopyArray((uint8_t*)&cau8GUIStat01, pu8TextResponse, \
                                N_ELEMENTS(cau8GUIStat01));
      *pu8TextSize = N_ELEMENTS(cau8GUIStat01);
      break;
    }
  }/* End switch/case */
  
  return (u32Status);
}
/*
 ******************************************************************************
 * u32fnGUISendResponseFrame
 ******************************************************************************
 */
uint32_t u32fnGUISendResponseFrame(const uint8_t* pu8Cmd,
                                   const uint8_t* pu8RawResponse, 
                                   const uint8_t* pu8Size,
                                   const uint8_t* pu8TextResponse,
                                   const uint8_t  u8TextSize)
{
  uint32_t u32LocalStatus;
  uint32_t u32LocalTime;
  uint8_t  au8MinTime[2u];
  uint8_t  au8ASCIIArray[50];
  
  u32LocalStatus = CLEAR;
  
  /* Construct response array */
  /* Transfer Command and arg info to the data array */
  au8ASCIIArray[LV_RESPONSE_CMD] = *pu8Cmd;
  au8ASCIIArray[LV_RESPONSE_ARG1] = *(pu8Cmd + 1u);
  au8ASCIIArray[LV_RESPONSE_ARG2] = *(pu8Cmd + 2u);
  au8ASCIIArray[LV_RESPONSE_ARG3] = *(pu8Cmd + 3u);
  
  /* Figure out what the time is, and store the */
  /* last two bytes in the data array */
  SCHED_WHAT_IS_THE_TIME(u32LocalTime);
  au8MinTime[CLEAR] = (uint8_t)(u32LocalTime >> BITS_IN_24);
  au8MinTime[TRUE]  = (uint8_t)(u32LocalTime >> BITS_IN_16);
  vfnHexToASCII((uint8_t*)au8MinTime, 
                (uint8_t*)&au8ASCIIArray[LV_RESPONSE_TIME],
                N_ELEMENTS(au8MinTime));
 
  
  /* Do the same for the actual data */
  vfnHexToASCII((uint8_t*)(pu8RawResponse), 
                (uint8_t*)&(au8ASCIIArray[LV_RESPONSE_PASS]),
                (uint16_t)(*pu8Size));
  
  /* Allow any pending message to finish */
  (void)u8fnLVWaitForTxPort();
  
  /* Now construct and send our message */
  u32LocalStatus = u8fnLabViewSendMSorMP((uint8_t*)au8ASCIIArray, 
                                         ((*pu8Size * 2u) + LV_RESPONSE_ADDER),
                                         LV_SEND_SERIALLY, LV_TI_MSG);
  /* Allow any pending message to finish */
    (void)u8fnLVWaitForTxPort();
  u32LocalStatus = u8fnLabViewSendMSorMP((uint8_t*)pu8TextResponse, 
                                           u8TextSize,
                                           LV_SEND_SERIALLY, LV_TS_MSG);
//#ifdef DEBUGGING_NOW
//  DELAY_SEC(3u);
//#endif
  return(u32LocalStatus);
}
/*
 ******************************************************************************
 * vfnGUISBCCapTests
 ******************************************************************************
 */
void vfnGUISBCCapTests(uint8_t* pu8Size, uint8_t* pu8RawResponse,
                       uint8_t u8ERx, uint8_t u8Test)
{
  /* locals */ 
  uint8_t u8Counter;
  uint32_t u32Status;
  
  u32Status = CLEAR;
  
  if(u8ERx < 0x06u)
  {
    u32Status = u32fnSBCPerformInitialTestsPOM(u8ERx, u8Test);
  }
  else
  {
    for(u8Counter = CLEAR; u8Counter < 6u; u8Counter++)
    {
      u32Status |= u32fnSBCPerformInitialTestsPOM(u8Counter, u8Test);
    }
  }
  
  /* Pass or fail criteria for this test is simple - if the Status */
  /* word is clear, we have passed, otherwise, we've failed. */
  *pu8RawResponse = (CLEAR == u32Status);
  /* We will send the status byte as part of the response. */
  *(pu8RawResponse + 1u) = (uint8_t)(u32Status >> BITS_IN_24);
  *(pu8RawResponse + 2u) = (uint8_t)(u32Status >> BITS_IN_16);
  *(pu8RawResponse + 3u) = (uint8_t)(u32Status >> BITS_IN_BYTE);
  *(pu8RawResponse + 4u) = (uint8_t)u32Status;
  *pu8Size = 5u;
  
  return;
}
/*
 ******************************************************************************
 * vfnGUISBCLeakageTests
 ******************************************************************************
 */
void vfnGUISBCLeakageTests(const uint8_t cu8Side,
                           const uint8_t cu8Squib, 
                           const uint8_t cu8LeakageType, 
                           uint8_t* pu8Result)
{
  uint32_t u32Status;
  uint8_t  u8Test;
  uint16_t u16ADCReading;
  
  u32Status = CLEAR;
  u8Test = CLEAR;
  
  /* Select either low-side or high-side elements */
  if(TRUE == cu8Side)
  {
    u8Test = cau8SBCInitialTestAoutRoutesIGL[cu8Squib];
  }
  else if(CLEAR == cu8Side)
  {
    u8Test = cau8SBCInitialTestAoutRoutesIGH[cu8Squib];
  }
  else
  {
    u8Test = CLEAR;
  }
  
  /* The test is performed here */
  /* Route the correct voltage value IGHx to AOUT */
  /* and Perform high leakage diagnosis */
  u32Status = u32fnSBCFLMLeakageMeasP1(u8Test, cu8LeakageType);
  DELAY_MSEC(2u);
  u32Status |= u32fnSBCFLMLeakageMeasP2((uint8_t)cu8LeakageType, 
                                        u8Test, 
                                        (uint16_t*)&u16ADCReading);
  DELAY_MSEC(2u);
  
  /* Store result */
  *pu8Result = (uint8_t)(CLEAR == u32Status);
  *(pu8Result + 1u) = (uint8_t)(u32Status >> BITS_IN_24);
  *(pu8Result + 2u) = (uint8_t)(u32Status >> BITS_IN_16);
  *(pu8Result + 3u) = (uint8_t)(u32Status >> BITS_IN_BYTE);
  *(pu8Result + 4u) = (uint8_t)u32Status;
  *(pu8Result + 5u) = (uint8_t)(u16ADCReading >> BITS_IN_BYTE);
  *(pu8Result + 6u) = (uint8_t)(u16ADCReading);
  
  return;
}
/*
 ******************************************************************************
 * vfnVerifyValidityOfCmd
 ******************************************************************************
 */
void vfnGUICheckSatellites(const uint16_t* pu16Mask, 
                           uint8_t* pu8Result)
{
  uint32_t au32LocalSchedResults[128];
  uint16_t  u16Mask;
  uint8_t   u8Counter;
  uint16_t u16Status;
  
  u8Counter = CLEAR;
  u16Status = CLEAR;
  u16Mask = BIT0;
  
  /* In order to read back satellites, we must: */
  /* 1) Turn the CG147 into Programming mode */
  /* 2) Turn power supplies off */
  /* 3) Wait    */
  /* 4) Turn on power supplies */
  /* 5) Gather data */
  /* 6) Reconfigure CG147 as before and exit */
  
  /* 1, 2, 3, & 4: reset the device to unlock EOP */
  (void)u8fnLaunchScheduler(CLEAR);
  vfnSBCPreSchedulerInit();
  (void)u8fnLaunchScheduler(TRUE);
  
  /* Transfer initial settings back to device, including WD */
  (void)u8fnCG147ScheduleBatchTransfer(CG147_SPI_CONFIG,
                                 (uint8_t*)&cau8CG147InitCmdsIn16Bit,
                                 (uint8_t*)&cau8CG147InitArgsIn16Bit,
                                 (uint16_t*)&au32LocalSchedResults,
                                 cu8CG147InitCmdsArgsSize,
                                 (uint32_t*)&gu32SBCTime);
  (void)u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT,
                                      SBC_WD2_TRIGGER,
                                      SBC_WD_RESPONSE_8,
                                      (uint16_t*)&gu32CG147WatchDog2RequestToMCU,
                                      (uint32_t*)&gu32SBCTime);
  (void)u8fnCG147ScheduleSafeTransfer(CG147_SPI_CONFIG_EXT,
                                      SBC_WD3_TRIGGER,
                                      SBC_WD_RESPONSE_8,
                                      (uint16_t*)&gu32CG147WatchDog3RequestToMCU,
                                      (uint32_t*)&gu32SBCTime);
  /* Here we wait for the scheduler to send the above SPI frames */
  while(1u > u32fnSchedIsTxDone(gu32SBCTime))
  {
    /* Wait here */
  };
  
  /* 5): Here we gather all the data and store it in RAM */
  u16Status = u16fnSBCGatherPSI5SatelliteData((uint8_t*)&gu8SBCSatelliteData);
  
  /*6)  We will now reset and restart */
  (void)u8fnLaunchScheduler(CLEAR);
  vfnSBCPreSchedulerInit();
  (void)u8fnLaunchScheduler(TRUE);
  (void)u32fnSBCInit();
  (void)u8fnSBCSchedulePSync();
  DELAY_MSEC(1u);
  
  /* Next we will verify that all sensors are happy */
  *pu8Result = (uint8_t)(u16Status >> 15u);
  
  for(u8Counter = 1u; u8Counter <= 12u; u8Counter++)
  {
    u16Mask <<= 1u;
    if(u16Mask & *pu16Mask)
    {
      *(pu8Result + u8Counter) = gu8SBCSatelliteData[DEVCFG1 * u8Counter];
      
    }
    else
    {
      /* Nothing */
    }
  }
  
  return;
}
/*
 ******************************************************************************
 * vfnVerifyValidityOfCmd
 ******************************************************************************
 */
void vfnVerifyValidityOfCmd(const uint8_t* pu8Cmd, 
                            const GUICmdString_t* ptValidCmd,
                            const uint16_t u16TableSize,
                            uint8_t* pu8Result)
{
  uint16_t u16Counter1;
  
  *pu8Result = CLEAR;
  
  /* We will verify all instances of the table */
  for(u16Counter1 = CLEAR; u16Counter1 < u16TableSize; u16Counter1++)
  {
    /* If the command is in the table, we will procede with more verification */
    if(*(pu8Cmd + 1u) == ptValidCmd[u16Counter1].A[CLEAR])
    {
      if((*(pu8Cmd + 2u) == ptValidCmd[u16Counter1].A[1u]) ||
           (ptValidCmd[u16Counter1].A[1u] == '*')) 
      {
        if((*(pu8Cmd + 3u) == ptValidCmd[u16Counter1].A[2u]) ||
           (ptValidCmd[u16Counter1].A[2u] == '*')) 
        {              
          /* Command is valid
          *pu8Result = TRUE;
          break;
        }
        else
        {
          /* Nothing */
        }
      }
      else
      {
        /* Nothing */
      }
    }
    else
    {
      /* Loop */
    }
  }
  
  return;
}
/*
 ******************************************************************************
 * vfnVerifyValidityOfCmd
 ******************************************************************************
 */
void vfnGUISatAndSquibState(const uint8_t u8Mode, const uint16_t cu16Step)
{
  static uint8_t au8Result[256];
  static uint16_t u16Token;
  uint16_t u16Counter;
  
  u16Counter = CLEAR;
  
  /* We will construct an ASCII message with a list of active satellites */
  /* and squibs. au8Result will be our place-holder. */
  
  /* Broken down into steps because of time constrains */
  switch(cu16Step)
  {
    /* First we do the operation for squibs */
    case(0u):
    {
      u16Token = N_ELEMENTS(cau8GUIStat03);
      break;
    }
    case(1u):
    {
      vfnCopyArray((uint8_t*)cau8GUIStat03, 
                   (uint8_t*)au8Result, 
                   u16Token);
      break;
    }
    case(2u):
    {
      for(u16Counter = BIT0; u16Counter < BIT5; u16Counter <<= BIT0)
      {
        vfnHexToASCIIMaskToList(gu16ActiveSquibChannels,
                                (uint8_t*)au8Result,
                                (uint16_t*)&u16Token,
                                u16Counter);
      }
      break;
    }
    case(3u):
    {
      for(u16Counter = BIT5; u16Counter < BIT9; u16Counter <<= BIT0)
      {
        vfnHexToASCIIMaskToList(gu16ActiveSquibChannels,
                                (uint8_t*)au8Result,
                                (uint16_t*)&u16Token,
                                u16Counter);
      }
      break;
    }
    case(4u):
    {
      for(u16Counter = BIT9; u16Counter < BIT12; u16Counter <<= BIT0)
      {
        vfnHexToASCIIMaskToList(gu16ActiveSquibChannels,
                                (uint8_t*)au8Result,
                                (uint16_t*)&u16Token,
                                u16Counter);
      }
      break;
    }
    case(5u):
    {
      u16Token -= 2u;
      au8Result[u16Token++] = '.';
      au8Result[u16Token++] = ' ';
    }
    case(6u):
    {
      /* We then do the same thing for satellites */
      vfnCopyArray((uint8_t*)cau8GUIStat04, 
                   (uint8_t*)&au8Result[u16Token], 
                   N_ELEMENTS(cau8GUIStat04));
      break;
    }
    case(7u):
    {
      u16Token += N_ELEMENTS(cau8GUIStat04);
      break;
    }
    case(8u):
    {
      for(u16Counter = BIT0; u16Counter < BIT5; u16Counter <<= BIT0)
      {
        vfnHexToASCIIMaskToList(gu16ActivePSI5Channels,
                                (uint8_t*)au8Result,
                                (uint16_t*)&u16Token,
                                u16Counter);
      }
      break;
    }
    case(9u):
    {
      for(u16Counter = BIT5; u16Counter < BIT9; u16Counter <<= BIT0)
      {
        vfnHexToASCIIMaskToList(gu16ActivePSI5Channels,
                                (uint8_t*)au8Result,
                                (uint16_t*)&u16Token,
                                u16Counter);
      }
      break;
    }
    case(10u):
    {
      for(u16Counter = BIT9; u16Counter < BIT12; u16Counter <<= BIT0)
      {
        vfnHexToASCIIMaskToList(gu16ActivePSI5Channels,
                                (uint8_t*)au8Result,
                                (uint16_t*)&u16Token,
                                u16Counter);
      }
      break;
    }
    case(11u):
    {
      u16Token -= 2u;
      au8Result[u16Token++] = '.';
      /* MS/MP won't take any message that is greater than 255 characters */
      if(u16Token > UCHAR_MAX)
      {
        u16Token = UCHAR_MAX;
      }
      else
      {
        /* Let it be */
      }
      break;
    }
    case(12u):
    {
      /* And we send out our data */
      (void)u8fnLabViewSendMSorMP((uint8_t*)au8Result, 
                                  (uint8_t)u16Token, 
                                  u8Mode,
                                  LV_MS_MSG);
      break;
    }
    default:
    {
      /* Leave */
    }
  }
  return;
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */